JavaScript Modul Proksi Patternlari: Kirishni Boshqarishni O'zlashtirish

            var myModule = (function() {
  // Xususiy o'zgaruvchilar va funksiyalar
  var privateCounter = 0;

  function privateIncrement() {
    privateCounter++;
    console.log('Private counter:', privateCounter);
  }

  // Ommaviy kirish mumkin bo'lgan metodlar va xususiyatlar
  function publicIncrement() {
    privateIncrement();
  }

  function getCounter() {
    return privateCounter;
  }

  // Ommaviy interfeysni oshkor qilish
  return {
    increment: publicIncrement,
    count: getCounter
  };
})();

// Foydalanish:
myModule.increment(); // Logs: Private counter: 1
console.log(myModule.count()); // Logs: 1
// console.log(myModule.privateCounter); // undefined (xususiy)
// myModule.privateIncrement(); // TypeError: myModule.privateIncrement is not a function (xususiy)

            

              
                Copy
              
            
          

            // Foydalanuvchi autentifikatsiyasi uchun murakkab quyi tizimni tasavvur qiling
var AuthSubsystem = {
  login: function(username, password) {
    console.log(`Authenticating user: ${username}`);
    // ... murakkab autentifikatsiya mantig'i ...
    return true;
  },
  logout: function(userId) {
    console.log(`Logging out user: ${userId}`);
    // ... murakkab tizimdan chiqish mantig'i ...
    return true;
  },
  resetPassword: function(email) {
    console.log(`Resetting password for: ${email}`);
    // ... parolni tiklash mantig'i ...
    return true;
  }
};

// Fasad moduli
var AuthFacade = (function() {
  function authenticateUser(username, password) {
    // Quyi tizimni chaqirishdan oldin asosiy tekshiruv
    if (!username || !password) {
      console.error('Username and password are required.');
      return false;
    }
    return AuthSubsystem.login(username, password);
  }

  function endSession(userId) {
    if (!userId) {
      console.error('User ID is required to end session.');
      return false;
    }
    return AuthSubsystem.logout(userId);
  }

  // Biz bu misol uchun resetPassword'ni fasad orqali bevosita ochmaslikni tanlaymiz
  // Ehtimol, u boshqa xavfsizlik kontekstini talab qiladi.

  return {
    login: authenticateUser,
    logout: endSession
  };
})();

// Foydalanish:
AuthFacade.login('globalUser', 'securePass123'); // Authenticating user: globalUser
AuthFacade.logout(12345);
// AuthFacade.resetPassword('test@example.com'); // TypeError: AuthFacade.resetPassword is not a function

            

              
                Copy
              
            
          

            // Asl Modul (ichki qismida Modulni Oshkor Qilish Patternidan foydalanayotgan bo'lishi mumkin)
var ConfigModule = (function() {
  var config = {
    apiKey: 'super-secret-api-key-12345',
    databaseUrl: 'mongodb://localhost:27017/mydb',
    debugMode: false,
    featureFlags: ['newUI', 'betaFeature']
  };

  function toggleDebugMode() {
    config.debugMode = !config.debugMode;
    console.log(`Debug mode is now: ${config.debugMode}`);
  }

  function addFeatureFlag(flag) {
    if (!config.featureFlags.includes(flag)) {
      config.featureFlags.push(flag);
      console.log(`Added feature flag: ${flag}`);
    }
  }

  return {
    settings: config,
    toggleDebug: toggleDebugMode,
    addFlag: addFeatureFlag
  };
})();

// --- Endi, kirishni boshqarish uchun Proksi qo'llaymiz ---

function createConfigProxy(module, userRole) {
  const protectedProperties = ['apiKey', 'databaseUrl'];

  const handler = {
    get: function(target, property) {
      // Agar xususiyat himoyalangan va foydalanuvchi admin bo'lmasa
      if (protectedProperties.includes(property) && userRole !== 'admin') {
        console.warn(`Access denied: Cannot read protected property '${property}' as a ${userRole}.`);
        return undefined; // Yoki xato qaytarish
      }
      // Agar xususiyat funksiya bo'lsa, uning to'g'ri kontekstda chaqirilishini ta'minlang
      if (typeof target[property] === 'function') {
        return target[property].bind(target); // 'this' to'g'ri bo'lishini ta'minlash uchun bind qilish
      }
      return target[property];
    },
    set: function(target, property, value) {
      // Admin bo'lmaganlar tomonidan himoyalangan xususiyatlarni o'zgartirishni oldini olish
      if (protectedProperties.includes(property) && userRole !== 'admin') {
        console.warn(`Access denied: Cannot write to protected property '${property}' as a ${userRole}.`);
        return false; // Muvaffaqiyatsizlikni bildirish
      }
      // Asl sxemaning bir qismi bo'lmagan xususiyatlarni qo'shishni oldini olish (ixtiyoriy)
      if (!target.hasOwnProperty(property)) {
         console.warn(`Access denied: Cannot add new property '${property}'.`);
         return false;
      }
      target[property] = value;
      console.log(`Property '${property}' set to:`, value);
      return true;
    }
  };

  // Modul ichidagi 'settings' obyektini proksi qilamiz
  const proxiedConfig = new Proxy(module.settings, handler);

  // Proksilangan sozlamalar va ruxsat etilgan metodlarni oshkor qiladigan yangi obyektni qaytaramiz
  return {
    getSetting: function(key) { return proxiedConfig[key]; }, // Aniq o'qish uchun getSetting dan foydalaning
    setSetting: function(key, val) { proxiedConfig[key] = val; }, // Aniq yozish uchun setSetting dan foydalaning
    toggleDebug: module.toggleDebug,
    addFlag: module.addFlag
  };
}

// --- Turli rollar bilan foydalanish ---

const regularUserConfig = createConfigProxy(ConfigModule, 'user');
const adminUserConfig = createConfigProxy(ConfigModule, 'admin');

console.log('--- Regular User Access ---');
console.log('API Key:', regularUserConfig.getSetting('apiKey')); // Ogohlantirishni chiqaradi, undefined qaytaradi
console.log('Debug Mode:', regularUserConfig.getSetting('debugMode')); // Logs: false
regularUserConfig.toggleDebug(); // Logs: Debug mode is now: true
console.log('Debug Mode after toggle:', regularUserConfig.getSetting('debugMode')); // Logs: true
regularUserConfig.addFlag('newFeature'); // Bayroq qo'shadi

console.log('\n--- Admin User Access ---');
console.log('API Key:', adminUserConfig.getSetting('apiKey')); // Logs: super-secret-api-key-12345
adminUserConfig.setSetting('apiKey', 'new-admin-key-98765'); // Logs: Property 'apiKey' set to: new-admin-key-98765
console.log('Updated API Key:', adminUserConfig.getSetting('apiKey')); // Logs: new-admin-key-98765
adminUserConfig.setSetting('databaseUrl', 'sqlite://localhost'); // Ruxsat etilgan

// Oddiy foydalanuvchi sifatida yangi xususiyat qo'shishga urinish
// regularUserConfig.setSetting('newProp', 'value'); // Ogohlantirish chiqaradi, jimgina muvaffaqiyatsiz bo'ladi

            

              
                Copy
              
            
          

            // Moliyaviy operatsiyalarni simulyatsiya qiluvchi modul
var TransactionModule = (function() {
  var balance = 1000;
  var transactionLimit = 500;
  var historicalTransactions = [];

  function processDeposit(amount) {
    if (amount <= 0) {
      console.error('Deposit amount must be positive.');
      return false;
    }
    balance += amount;
    historicalTransactions.push({ type: 'deposit', amount: amount });
    console.log(`Deposit successful. New balance: ${balance}`);
    return true;
  }

  function processWithdrawal(amount) {
    if (amount <= 0) {
      console.error('Withdrawal amount must be positive.');
      return false;
    }
    if (amount > balance) {
      console.error('Insufficient funds.');
      return false;
    }
    if (amount > transactionLimit) {
      console.error(`Withdrawal amount exceeds transaction limit of ${transactionLimit}.`);
      return false;
    }
    balance -= amount;
    historicalTransactions.push({ type: 'withdrawal', amount: amount });
    console.log(`Withdrawal successful. New balance: ${balance}`);
    return true;
  }

  function getBalance() {
    return balance;
  }

  function getTransactionHistory() {
    // Tashqi o'zgartirishlarni oldini olish uchun nusxasini qaytarish kerak bo'lishi mumkin
    return [...historicalTransactions];
  }

  return {
    deposit: processDeposit,
    withdraw: processWithdrawal,
    balance: getBalance,
    history: getTransactionHistory
  };
})();

// --- Foydalanuvchi sessiyasiga asoslangan operatsiyalarni boshqarish uchun Proksi ---

function createTransactionProxy(module, isAuthenticated) {
  const handler = {
    // Funksiya chaqiruvlarini to'xtatish
    get: function(target, property, receiver) {
      const originalMethod = target[property];

      if (typeof originalMethod === 'function') {
        // Agar bu tranzaksiya metodi bo'lsa, uni autentifikatsiya tekshiruvi bilan o'rab oling
        if (property === 'deposit' || property === 'withdraw') {
          return function(...args) {
            if (!isAuthenticated) {
              console.warn(`Access denied: User is not authenticated to perform '${property}'.`);
              return false;
            }
            // Argumentlarni asl metodga o'tkazing
            return originalMethod.apply(this, args);
          };
        }
        // getBalance, history kabi boshqa metodlar uchun, agar mavjud bo'lsa, kirishga ruxsat bering
        return originalMethod.bind(this);
      }
      // 'balance', 'history' kabi xususiyatlar uchun ularni to'g'ridan-to'g'ri qaytaring
      return originalMethod;
    }
    // Agar kerak bo'lsa, transactionLimit kabi xususiyatlar uchun 'set' ni ham amalga oshirishimiz mumkin edi
  };

  return new Proxy(module, handler);
}

// --- Foydalanish ---

console.log('\n--- Transaction Module with Proxy ---');

const unauthenticatedTransactions = createTransactionProxy(TransactionModule, false);
const authenticatedTransactions = createTransactionProxy(TransactionModule, true);

console.log('Initial Balance:', unauthenticatedTransactions.balance()); // 1000

console.log('\n--- Performing Transactions (Unauthenticated) ---');
unauthenticatedTransactions.deposit(200);
// Ogohlantirish chiqaradi: Access denied: User is not authenticated to perform 'deposit'. Returns false.
unauthenticatedTransactions.withdraw(100);
// Ogohlantirish chiqaradi: Access denied: User is not authenticated to perform 'withdraw'. Returns false.
console.log('Balance after attempted transactions:', unauthenticatedTransactions.balance()); // 1000

console.log('\n--- Performing Transactions (Authenticated) ---');
authenticatedTransactions.deposit(300);
// Logs: Deposit successful. New balance: 1300
authenticatedTransactions.withdraw(150);
// Logs: Withdrawal successful. New balance: 1150
console.log('Balance after successful transactions:', authenticatedTransactions.balance()); // 1150

console.log('Transaction History:', authenticatedTransactions.history());
// Logs: [ { type: 'deposit', amount: 300 }, { type: 'withdrawal', amount: 150 } ]

// Limitdan oshib ketadigan yechib olishga urinish
authenticatedTransactions.withdraw(600);
// Logs: Withdrawal amount exceeds transaction limit of 500. Returns false.

            

              
                Copy
              
            
          

            // Misol: Kirishni boshqarish uchun Modulni Oshkor Qilish Patternini Proksi bilan birlashtirish

function createSecureDataAccessModule(initialData, userPermissions) {
  // Ichki tuzilma va asosiy inkapsulyatsiya uchun Modulni Oshkor Qilish Patternidan foydalaning
  var privateData = initialData;
  var permissions = userPermissions;

  function readData(key) {
    if (permissions.read.includes(key)) {
      return privateData[key];
    }
    console.warn(`Read access denied for key: ${key}`);
    return undefined;
  }

  function writeData(key, value) {
    if (permissions.write.includes(key)) {
      privateData[key] = value;
      console.log(`Successfully wrote to key: ${key}`);
      return true;
    }
    console.warn(`Write access denied for key: ${key}`);
    return false;
  }

  function deleteData(key) {
    if (permissions.delete.includes(key)) {
      delete privateData[key];
      console.log(`Successfully deleted key: ${key}`);
      return true;
    }
    console.warn(`Delete access denied for key: ${key}`);
    return false;
  }

  // Ommaviy API'ni qaytaring
  return {
    getData: readData,
    setData: writeData,
    deleteData: deleteData,
    listKeys: function() { return Object.keys(privateData); }
  };
}

// Endi, bu modulning ommaviy API'sini yanada nozik nazorat yoki dinamik sozlashlar uchun Proksi bilan o'rang

function createProxyWithExtraChecks(module, role) {
  const handler = {
    get: function(target, property) {
      // Qo'shimcha tekshiruv: balki 'listKeys' faqat admin rollari uchun ruxsat etilgan
      if (property === 'listKeys' && role !== 'admin') {
        console.warn('Operation listKeys is restricted to admin role.');
        return () => undefined; // Soxta funksiyani qaytarish
      }
      // Asl modul metodlariga topshirish
      return target[property];
    },
    set: function(target, property, value) {
      // Faqat setData orqali sozlanayotganiga ishonch hosil qiling, qaytarilgan obyektda to'g'ridan-to'g'ri emas
      if (property === 'setData') {
        // Bu tuzoq target.setData ga tayinlash urinishlarini to'xtatadi
        console.warn('Cannot directly reassign the setData method.');
        return false;
      }
      // Boshqa xususiyatlar uchun (metodlarning o'zi kabi), qayta tayinlashni oldini olishni xohlaymiz
      if (typeof target[property] === 'function') {
        console.warn(`Attempted to reassign method '${property}'.`);
        return false;
      }
      return target[property] = value;
    }
  };

  return new Proxy(module, handler);
}


// --- Foydalanish ---

const userPermissions = {
  read: ['username', 'email'],
  write: ['email'],
  delete: []
};

const userDataModule = createSecureDataAccessModule({
  username: 'globalUser',
  email: 'user@example.com',
  preferences: { theme: 'dark' }
}, userPermissions);

const proxiedUserData = createProxyWithExtraChecks(userDataModule, 'user');
const proxiedAdminData = createProxyWithExtraChecks(userDataModule, 'admin'); // Admin haqiqiy stsenariyda yuqoriroq ruxsatnomalar orqali to'liq kirishga ega deb taxmin qilinadi

console.log('\n--- Combined Pattern Usage ---');

console.log('User Data:', proxiedUserData.getData('username')); // globalUser
console.log('User Prefs:', proxiedUserData.getData('preferences')); // undefined (o'qish ruxsatnomalarida yo'q)

proxiedUserData.setData('email', 'new.email@example.com'); // Ruxsat etilgan
proxiedUserData.setData('username', 'anotherUser'); // Rad etilgan

console.log('User Email:', proxiedUserData.getData('email')); // new.email@example.com

console.log('Keys (User):', proxiedUserData.listKeys()); // Ogohlantirish chiqaradi: Operation listKeys is restricted to admin role. Returns undefined.

console.log('Keys (Admin):', proxiedAdminData.listKeys()); // [ 'username', 'email', 'preferences' ]

// Metodni qayta tayinlashga urinish
// proxiedUserData.getData = function() { return 'hacked'; }; // Ogohlantirish chiqaradi, muvaffaqiyatsiz bo'ladi

            

              
                Copy